// pages/community/shareEdit/shareEdit.js
const api = require('../../../utils/api');

Page({
  data: {
    title: '',       // 分享标题
    content: '',     // 分享内容
    images: [],      // 图片数组
    userInfo: null,  // 用户信息
    isLogin: false   // 登录状态
  },

  // 页面加载
  onLoad(options) {
    // 初始化服务器图片URL变量
    this.serverImageUrls = [];
    // 加载用户信息
    this.loadUserInfo();
    // 处理编辑模式
    if (options && options.id) {
      this.setData({
        isEditMode: true,
        shareId: options.id
      });
      
      // 如果传入了分享数据，则预填充表单
      if (options.title) {
        this.setData({
          title: decodeURIComponent(options.title),
          content: decodeURIComponent(options.content || options.desc || ''),
          images: JSON.parse(decodeURIComponent(options.imageUrls || '[]'))
        });
      } else {
        // 从本地存储中查找该分享项
        this.loadShareData(options.id);
      }
    }
  },
  
  // 页面显示时再次检查用户信息
  onShow() {
    this.loadUserInfo();
  },
  

  // 加载用户信息
  async loadUserInfo() {
    try {
      const userInfo = wx.getStorageSync('userInfo');
      const token = wx.getStorageSync('token');
      
      if (userInfo && token) {
          // 尝试从服务器获取最新的用户信息
        try {
          // 获取用户ID
          const userId = userInfo.userId || userInfo.id;
          if (userId && userId !== 'local' && userId !== 1) {
            console.log('尝试从服务器获取最新用户信息，用户ID:', userId);
            const res = await api.my.getUserInfo(userId);
            
            if (res && res.data && res.data.code === 200) {
              const serverUserInfo = res.data.data;
              console.log('成功从服务器获取用户信息:', serverUserInfo);
              
              // 合并本地和服务器的用户信息
              const mergedUserInfo = {
                ...userInfo,
                ...serverUserInfo
              };
              
              // 更新本地存储
              wx.setStorageSync('userInfo', mergedUserInfo);
              
              // 更新页面数据
              this.setData({
                userInfo: mergedUserInfo
              });
              console.log('已更新本地存储和页面的用户信息');
            }
          }
        } catch (serverError) {
          console.warn('从服务器获取用户信息失败，继续使用本地数据:', serverError);
          // 服务器错误不影响使用本地数据
        }
      } else {
        console.log('未找到用户信息或未登录');
        this.setData({
          userInfo: null,
          isLogin: false
        });
      }
    } catch (error) {
      console.error('加载用户信息失败:', error);
      this.setData({
        userInfo: null,
        isLogin: false
      });
    }
  },
  
  // 加载分享数据
  loadShareData(shareId) {
    wx.showLoading({
      title: '加载中...',
    });
      console.log('直接从服务器获取分享ID:', shareId);
      
      // 直接从服务器获取数据
      this.fetchShareFromServer(shareId).then(() => {
        wx.hideLoading();
      }).catch(() => {
        wx.hideLoading();
      });
      return;
    /*
    }
    
    wx.hideLoading();*/
  },
  // 标题输入处理
  onTitleInput(e) {
    this.setData({
      title: e.detail.value
    });
  },

  // 内容输入处理
  onContentInput(e) {
    this.setData({
      content: e.detail.value
    });
  },

  // 选择图片
  async chooseImage() {
    const that = this;
    const remainingSlots = 9 - that.data.images.length;

    if (remainingSlots <= 0) {
      wx.showToast({
        title: '最多只能上传9张图片',
        icon: 'none'
      });
      return;
    }

    wx.chooseMedia({
      count: remainingSlots,
      mediaType: ['image'],
      sizeType: ['compressed'],
      sourceType: ['album', 'camera'],
      success: async (res) => {
        // 获取选择的图片临时路径
        const tempFilePaths = res.tempFiles.map(file => file.tempFilePath);
        
        wx.showLoading({
          title: '上传中...',
        });
        
        try {
          // 上传图片到OSS
          const uploadedUrls = await that.uploadImages(tempFilePaths);
          
          // 添加到现有图片数组
          that.setData({
            images: [...that.data.images, ...uploadedUrls]
          });
          
          console.log('上传成功的图片URL:', uploadedUrls);
        } catch (error) {
          console.error('图片上传失败:', error);
          wx.showToast({
            title: '图片上传失败',
            icon: 'none'
          });
        } finally {
          wx.hideLoading();
        }
      },
      fail(err) {
        console.error('选择图片失败:', err);
        if (err.errMsg !== "chooseMedia:fail cancel") {
          wx.showToast({
            title: '选择图片失败',
            icon: 'none'
          });
        }
      }
    });
  },
  //上传图片
  async uploadImages(tempFilePaths) {
    const token = wx.getStorageSync('token');
    const uploadedUrls = [];
    
    for (const filePath of tempFilePaths) {
      try {
        const result = await api.allUse.uploadFiles({
          filePath: filePath,
          businessType: 'community', 
          fileType: 'image',
          token: token
        });
        
        // 假设返回的result中包含图片URL
        if (result && result.url) {
          uploadedUrls.push(result.url);
        } else {
          console.error('上传成功但未返回URL:', result);
          // 如果上传成功但没有返回URL，使用临时路径作为备份
          uploadedUrls.push(filePath);
        }
      } catch (error) {
        console.error(`上传单个图片失败: ${filePath}`, error);
        // 上传失败时使用临时路径作为备份
        uploadedUrls.push(filePath);
      }
    }
    
    return uploadedUrls;
  },

  // 删除图片
  deleteImage(e) {
    const index = e.currentTarget.dataset.index;
    const images = this.data.images;
    images.splice(index, 1);
    this.setData({
      images: images
    });
  },

  // 发布分享
  publishShare: async function() {
    try {
      // 增强：改进登录状态验证
      const token = wx.getStorageSync('token');
      const userInfo = wx.getStorageSync('userInfo') || {};
      
      // 表单验证
      if (!this.data.title.trim()) {
        wx.showToast({
          title: '标题不能为空',
          icon: 'none'
        });
        return;
      }

      if (!this.data.content.trim()) {
        wx.showToast({
          title: '内容不能为空',
          icon: 'none'
        });
        return;
      }
      
      wx.showLoading({
        title: '发布中...',
      });

      console.log('当前用户信息:', userInfo);
      
      // 确保图片URL已经上传到OSS
      const uploadedImages = await this.ensureImagesUploaded(this.data.images);
      
      // 准备发布数据，优先使用服务器返回的图片URL
      const publishData = {
        title: this.data.title.trim(),
        description: this.data.content.trim(),
        imageUrls: this.formatImageUrls(this.serverImageUrls || uploadedImages),
        userId: userInfo.userId || 'local'
      };
      
      console.log('准备发布数据，使用服务器图片URL:', publishData.imageUrls);
      // 只有非编辑模式才添加新的备份，编辑模式应该在后面更新现有条目
      if (!this.data.isEditMode) {
        const enhancedBackupShare = {
          ...publishData,
          createTime: new Date().toISOString(),
          favoriteCount: 0,
          commentCount: 0,
          isLiked: false,
          id: new Date().getTime(), // 添加临时ID用于前端显示
          isBackup: true
        };
        
        // 同时保存到两个本地存储键，确保兼容性和数据同步
        // 1. 保存到backupShares（兼容myShare.js使用）
        const backupShares = wx.getStorageSync('backupShares') || [];
        backupShares.unshift(enhancedBackupShare);
        wx.setStorageSync('backupShares', backupShares.slice(0, 10)); // 只保留最近10条备份
        
        // 2. 保存到cachedMyShares（用于communityMain.js）
        const cachedMyShares = wx.getStorageSync('cachedMyShares') || [];
        cachedMyShares.unshift(enhancedBackupShare);
        wx.setStorageSync('cachedMyShares', cachedMyShares.slice(0, 10));
        
        console.log('已保存到本地备份，同时更新两个存储键以确保数据同步');
      } else {
        console.log('编辑模式下跳过添加新的本地备份');
      }

      //根据登录状态分别处理
      if (token && userInfo.userId && userInfo.userId !== 1) {
        console.log('登录状态验证通过，使用实际用户ID发布/修改分享');
        
        try {
          // 根据是否为编辑模式调用不同API
          if (this.data.isEditMode && this.data.shareId) {
            // 编辑模式：添加ID并调用更新接口
            const updateData = {
              ...publishData,
              id: this.data.shareId
            };
            await api.community.updateShare(updateData);
            wx.showToast({ title: '修改成功', icon: 'success' });
          } else {
            // 创建模式：调用发布接口
            await api.community.publishShare(publishData);
            wx.showToast({ title: '发布成功', icon: 'success' });
          }
        } catch (error) {
          console.error('发布/修改失败:', error);
          wx.showToast({ 
            title: error.statusCode === 401 ? '登录过期，请重新登录' : '操作失败', 
            icon: 'none' 
          });
        } finally {
          wx.hideLoading();
          // 直接使用reLaunch跳转到社区页面
          setTimeout(() => {
            wx.reLaunch({ url: '/pages/community/communityMain/communityMain' });
          }, 1500);
        }
      } else {
        // 未登录或使用默认用户ID
        wx.hideLoading();
        wx.showToast({
          title: this.data.isEditMode ? '已保存修改' : '已保存',
          icon: 'success'
        });
        
        // 简化：直接跳转
        setTimeout(() => {
          wx.reLaunch({ url: '/pages/community/communityMain/communityMain' });
        }, 1500);
      }
    } catch (error) {
      console.error('发布过程出现异常:', error);
      wx.hideLoading();
      wx.showToast({
        title: '发布异常，请重试',
        icon: 'none'
      });
    }
  },
  
  //格式化图片URL
  formatImageUrls(imageUrls) {
    if (!Array.isArray(imageUrls)) return [];
    return imageUrls.filter(url => url && typeof url === 'string' && url.trim());
  },

  // 确保所有图片都已上传到OSS
  async ensureImagesUploaded(images) {
    const uploadedImages = [];
    const token = wx.getStorageSync('token');
    
    for (const img of images) {
      if (img.startsWith('http://') || img.startsWith('https://')) {
        uploadedImages.push(img);
      } else {
        try {
          const result = await api.allUse.uploadFiles({
            filePath: img,
            businessType: 'community',
            fileType: 'image',
            token: token
          });
          uploadedImages.push(result?.url || img);
        } catch (error) {
          console.error(`上传图片失败: ${img}`, error);
          uploadedImages.push(img);
        }
      }
    }
    
    this.serverImageUrls = uploadedImages;
    return uploadedImages;
  },

  // 取消编辑功能
  cancelEdit() {
    if (this.data.title.trim() || this.data.content.trim() || this.data.images.length > 0) {
      wx.showModal({
        title: '确认取消',
        content: '确定要取消编辑吗？未保存的修改将丢失。',
        success: (res) => {
          if (res.confirm) {
            wx.navigateBack();
          }
        }
      });
    } else {
      wx.navigateBack();
    }
  }
});